home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 4 / Amiga Tools 4.iso / tools / netzwerk / tcp-ip / ipdial_v1.9 / debug / IPDial.c < prev    next >
C/C++ Source or Header  |  1995-11-18  |  25KB  |  1,140 lines
  1. /**
  2. ***  IPDial     Script program for initializing a SLIP connection
  3. ***  Copyright  (C)   1994    Jochen Wiedmann
  4. ***
  5. ***  This program is free software; you can redistribute it and/or modify
  6. ***  it under the terms of the GNU General Public License as published by
  7. ***  the Free Software Foundation; either version 2 of the License, or
  8. ***  (at your option) any later version.
  9. ***
  10. ***  This program is distributed in the hope that it will be useful,
  11. ***  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. ***  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. ***  GNU General Public License for more details.
  14. ***
  15. ***  You should have received a copy of the GNU General Public License
  16. ***  along with this program; if not, write to the Free Software
  17. ***  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. ***
  19. ***
  20. ***  This is the main part of the program.
  21. ***
  22. ***
  23. ***  Computer: Amiga 1200                       Compiler: Dice 3.01
  24. ***
  25. ***  Author:    Jochen Wiedmann
  26. ***             Am Eisteich 9
  27. ***             72555 Metzingen
  28. ***             Germany
  29. ***
  30. ***             Phone: (+0049) 7123 / 14881
  31. ***             Internet: wiedmann@neckar-alb.de
  32. ***
  33. ***
  34. ***  History:   V 1.1   23.11.94        Initial version
  35. ***
  36. ***             V 1.2   27.02.95        Added terminal mode
  37. ***                                     Now using ReadArgs() for
  38. ***                                     command line parsing.
  39. ***
  40. ***             V 1.3   09.03.95        Added environment variable
  41. ***                                     aupport to "send" command.
  42. ***                                     Added unit support.
  43. ***
  44. ***             V 1.4   21.04.95        Added "system" command.
  45. ***                                     Added environment variable
  46. ***                                     support to "echo" command.
  47. ***                                     Terminal mode now converts
  48. ***                                     LF to CR/LF, so that modem
  49. ***                                     recognizes commands.
  50. ***                                     (Let's hope, that will still
  51. ***                                     work for entering passwords. :-(
  52. ***
  53. ***             V 1.5   30.04.95        Added "scan" command.
  54. ***
  55. ***             V 1.6   26.06.95        "delay" command supporting
  56. ***                                     ticks; ParseString()
  57. ***                                     supporting octal characters;
  58. ***                                     "wait" command using
  59. ***                                     ParseString()
  60. ***                                     (All Suggested by Will Bow.)
  61. ***
  62. ***                                     Fixed bug in SerialSend():
  63. ***                                     *.io_Device = *.io_Unit
  64. ***
  65. ***             V 1.7   22.07.95        Added ECHO, RAW and EOF options
  66. ***                                     to "terminal" command.
  67. ***                                     (Suggested by Klaus Heinz.)
  68. ***
  69. ***                                     Added BAUD option to command
  70. ***                                     line.
  71. ***
  72. ***                                     Added "setvar" command.
  73. ***
  74. ***             v 1.8   24.11.95        Put a 10 tick delay after the
  75. ***                                     DoIO() call in DeviceIODo()
  76. **/
  77. #define VERSION     1
  78. #define REVISION    8
  79. #define VSTRING     "IPDial 1.8 (24.11.95)"
  80. #define VERSTAG     "\0$VER: IPDial 1.8 (24.11.95)"
  81. /**
  82. ***  Include files
  83. **/
  84. #include "IPDial.h"
  85. #include <ctype.h>
  86. #include <clib/alib_protos.h>
  87. /**
  88. ***  This structure describes one command. All commands are stored
  89. ***  in a table at the end of the file.
  90. **/
  91. struct ScriptLine;
  92. typedef VOID (*CommandFunc) (struct ScriptLine *);
  93. struct Command
  94. { 
  95.   CommandFunc Func;
  96.   STRPTR Name;
  97. };
  98. /**
  99. ***  Each line of the script file is stored in a structure like below.
  100. **/
  101. struct ScriptLine
  102. { 
  103.   struct MinNode mn;
  104.   ULONG Num;
  105.   CommandFunc CommFunc;
  106.   STRPTR Label;
  107.   STRPTR Args;
  108. };
  109. /**
  110. ***  Global variables
  111. **/
  112. LONG StatusVar;
  113.  
  114. struct MinList ScriptLineList;
  115.  
  116. struct ScriptLine *CurrentScriptLine;
  117.  
  118. const UBYTE VersTag [] = VERSTAG;
  119. const UBYTE VString [] = VSTRING;
  120.  
  121. ULONG EchoMode = FALSE;
  122. ULONG VerboseMode = FALSE;
  123.  
  124. STRPTR SerialDeviceName = NULL;
  125.  
  126. struct RDArgs *MainRDArgs = NULL;
  127. /**
  128. ***  This function is used to skip blanks.
  129. **/
  130. STRPTR SkipBlanks(const UBYTE *ptr)
  131. { 
  132.   while(*ptr == ' '  ||  *ptr == '\t')
  133.   { 
  134.     ++ptr;
  135.   }
  136.   return((STRPTR) ptr);
  137. }
  138. /**
  139. ***  This function is used to parse a string for characters
  140. ***  like '\r' or '\n'. $VAR or ${VAR} may be used to insert
  141. ***  the value of environment variable VAR, $$ may be used to
  142. ***  insert the '$' character itself, likewise \\.
  143. ***
  144. ***  Returns a pointer to a string allocated with malloc().
  145. ***  It is the task of the caller, to free() this string.
  146. **/
  147. STRPTR ParseString(const UBYTE *ptr)
  148. { 
  149.   STRPTR result;
  150.   STATIC APTR parseBuffer = NULL;
  151.   /**
  152.   ***  Be sure, that buffer is valid.
  153.   **/
  154.   if (!parseBuffer  &&  !(parseBuffer = BufferCreate()))
  155.   { 
  156.     perror("malloc");
  157.     exit(10);
  158.   }
  159.   /**
  160.   ***  Clear the buffer.
  161.   **/
  162.   BufferClear(parseBuffer);
  163.  
  164.   while(*ptr)
  165.   { 
  166.     if (*ptr == '\\')
  167.     { 
  168.       ++ptr;
  169.       switch(*ptr)
  170.       { 
  171.         case 'r':
  172.             BufferExtend(parseBuffer, (STRPTR) "\r", 1);
  173.             break;
  174.           case 'n':
  175.             BufferExtend(parseBuffer, (STRPTR) "\n", 1);
  176.             break;
  177.           case '0':
  178.           case '1':
  179.           case '2':
  180.           case '3':
  181.           case '4':
  182.           case '5':
  183.           case '6':
  184.           case '7':
  185.             { 
  186.             char c;
  187.  
  188.               c = *ptr - '0';
  189.               if (ptr[1] >= '0'  &&  ptr[1] <= '7')
  190.               { 
  191.               c = (c << 3) + *(++ptr) - '0';
  192.                 if (ptr[1] >= '0'  &&  ptr[2] <= '7')
  193.                 { 
  194.                 c = (c << 3) + *(++ptr) - '0';
  195.                 }
  196.               }
  197.               BufferExtend(parseBuffer, (STRPTR) &c, 1);
  198.             }
  199.             break;
  200.           default:
  201.             BufferExtend(parseBuffer, ptr, 1);
  202.             break;
  203.       }
  204.       ++ptr;
  205.     }
  206.     else if (*ptr == '$')
  207.     { 
  208.       ++ptr;
  209.       if (*ptr == '$')
  210.       { 
  211.         BufferExtend(parseBuffer, (STRPTR) "$", 1);
  212.           ++ptr;
  213.       }
  214.       else
  215.       { 
  216.         char *varName;
  217.           const char* varPtr;
  218.           size_t varLen = 0;
  219.  
  220.           if (*ptr == '{')
  221.           { 
  222.           ++ptr;
  223.             varPtr = (const char*) ptr;
  224.             while (*ptr && *ptr != '}')
  225.             { 
  226.             ++ptr;
  227.               ++varLen;
  228.             }
  229.             if (*ptr == '}')
  230.             { 
  231.             ++ptr;
  232.             }
  233.           }
  234.           else
  235.           { 
  236.           varPtr = (const char*) ptr;
  237.             while (*ptr  &&  isalnum(*ptr))
  238.             { 
  239.             ++ptr;
  240.               ++varLen;
  241.             }
  242.           }
  243.  
  244.           if (!(varName = malloc(varLen + 1)))
  245.           { 
  246.           perror("malloc");
  247.             exit(10);
  248.           }
  249.           strncpy(varName, varPtr, varLen);
  250.           varName[varLen] = '\0';
  251.  
  252.           if ((varPtr = getenv(varName)))
  253.           { 
  254.           BufferExtend(parseBuffer, (STRPTR) varPtr, strlen(varPtr));
  255.           }
  256.       }
  257.     }
  258.     else
  259.     { 
  260.       BufferExtend(parseBuffer, ptr, 1);
  261.       ++ptr;
  262.     }
  263.   }
  264.  
  265.   BufferExtend(parseBuffer, (STRPTR) "", 1);
  266.  
  267.   if (!(result = (STRPTR) strdup((char*) BufferBuffer(parseBuffer))))
  268.   { 
  269.     perror("malloc");
  270.     exit(10);
  271.   }
  272.  
  273.   return(result);
  274. }
  275. /**
  276. ***  This is an empty function. Just to allow lines with labels only.
  277. **/
  278. VOID NoneFunc(struct ScriptLine *line)
  279. {
  280. }
  281. /**
  282. ***  This is the echo function.
  283. **/
  284. VOID EchoFunc(struct ScriptLine *line)
  285. { 
  286.   STRPTR *args;
  287.   int i;
  288.  
  289.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  290.   { 
  291.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  292.     exit(10);
  293.   }
  294.  
  295.   for(i = 0;  *args;  ++i, ++args)
  296.   { 
  297.     char *str;
  298.  
  299.     if (i)
  300.     { 
  301.       putchar(' ');
  302.     }
  303.     str = (char*) ParseString(*args);
  304.     fputs((char *) str, stdout);
  305.     fflush(stdout);
  306.     free(str);
  307.   }
  308. }
  309. /**
  310. ***  This is the device function.
  311. **/
  312. VOID DeviceFunc(struct ScriptLine *line)
  313. { 
  314.   struct
  315.   { 
  316.     STRPTR Device;
  317.     STRPTR Protocol;
  318.     LONG *Unit;
  319.   } args;
  320.  
  321.   if (SerialDeviceName)
  322.   { 
  323.     fprintf(stderr, "Line %ld: Device already open, ignoring.\n", line->Num);
  324.   }
  325.  
  326.   args.Unit = NULL;
  327.   args.Device = NULL;
  328.   args.Protocol = NULL;
  329.  
  330.   if (!StrReadArgs(line->Args, (LONG *) &args,
  331.           (STRPTR) "DEVICE,PROTOCOL,UNIT/K/N"))
  332.   { 
  333.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  334.     exit(10);
  335.   }
  336.  
  337.   if (!args.Device)
  338.   { 
  339.     fprintf(stderr, "Line %ld: Missing device name.\n", line->Num);
  340.     exit(10);
  341.   }
  342.   if (!(SerialDeviceName = (STRPTR) strdup((char *) args.Device)))
  343.   { 
  344.     perror("malloc");
  345.     exit(10);
  346.   }
  347.  
  348.   if (VerboseMode)
  349.   { 
  350.     printf("DeviceFunc: Opening %s.\n", args.Device);
  351.   }
  352.  
  353.   if (!SerialOpen(args.Device, args.Protocol, args.Unit ? *args.Unit : 0))
  354.   { 
  355.     fprintf(stderr, "Line %ld: Unknown protocol.\n", line->Num);
  356.     exit(10);
  357.   }
  358. }
  359. /**
  360. ***  This function is used to set the serial.device parameters.
  361. **/
  362. VOID SetFunc(struct ScriptLine *line)
  363. { 
  364.   struct
  365.   { 
  366.     ULONG *Baud;
  367.     ULONG *DataBits;
  368.     ULONG *StopBits;
  369.     ULONG *BufSize;
  370.     STRPTR Parity;
  371.     STRPTR Protocol;
  372.   } args;
  373.  
  374.   if (!SerialDeviceName)
  375.   { 
  376.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  377.     exit(10);
  378.   }
  379.  
  380.   args.Baud = NULL;
  381.   args.DataBits = NULL;
  382.   args.StopBits = NULL;
  383.   args.BufSize = NULL;
  384.   args.Parity = NULL;
  385.   args.Protocol = NULL;
  386.  
  387.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  388.           (STRPTR) "BAUD/K/N,DATABITS/K/N,STOPBITS/K/N,BUFSIZE/K/N,"
  389.           "PARITY/K,PROTOCOL/K")))
  390.   { 
  391.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  392.     exit(10);
  393.   }
  394.  
  395.   if (args.Baud)
  396.   { 
  397.     SerialSetBaud(*args.Baud);
  398.   }
  399.   if (args.DataBits)
  400.   { 
  401.     SerialSetDataBits(*args.DataBits);
  402.   }
  403.   if (args.StopBits)
  404.   { 
  405.     SerialSetStopBits(*args.StopBits);
  406.   }
  407.   if (args.BufSize)
  408.   { 
  409.     SerialSetBufSize(*args.BufSize);
  410.   }
  411.   if (args.Parity)
  412.   {
  413.     if (!SerialSetParity(args.Parity))
  414.     { 
  415.       fprintf(stderr, "Line %ld: Unknown parity.\n", line->Num);
  416.       exit(10);
  417.     }
  418.   }
  419.   if (args.Protocol)
  420.   {
  421.     if (!SerialSetProtocol(args.Protocol))
  422.     { 
  423.       fprintf(stderr, "Line %ld: Unknown protocol.\n", line->Num);
  424.       exit(10);
  425.     }
  426.   }
  427.  
  428.   if (VerboseMode)
  429.   { 
  430.     printf("SetFunc: %s Parameters modified:\n\n", SerialDeviceName);
  431.     SerialShowParms();
  432.   }
  433. }
  434. /**
  435. ***  This function shows the serial.device parameters.
  436. **/
  437. VOID ShowParmsFunc(struct ScriptLine *line)
  438. { 
  439.   if (!SerialDeviceName)
  440.   { 
  441.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  442.     exit(10);
  443.   }
  444.  
  445.   printf("%s Parameters:\n\n", SerialDeviceName);
  446.   SerialShowParms();
  447. }
  448. /**
  449. ***  This function sends a string to the serial.device.
  450. **/
  451. VOID SendFunc(struct ScriptLine *line)
  452. { 
  453.   STRPTR *args;
  454.  
  455.   if (VerboseMode)
  456.   { 
  457.     fflush(stdout);
  458.     printf("\nSendFunc: Sending: ");
  459.   }
  460.  
  461.  
  462.   if (!SerialDeviceName)
  463.   { 
  464.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  465.     exit(10);
  466.   }
  467.  
  468.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  469.   { 
  470.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  471.     exit(10);
  472.   }
  473.  
  474.   for(;  *args;  args++)
  475.   { 
  476.     STRPTR send = ParseString(*args);
  477.  
  478.     if (VerboseMode)
  479.       printf(" %s \n", send);
  480.       
  481.     SerialSend(send, strlen((char *) send));
  482.     free(send);
  483.   }
  484.  
  485.   if (VerboseMode)
  486.   { 
  487.     printf("\n");
  488.   }
  489. }
  490. /**
  491. ***  This is similar to "if".
  492. **/
  493. VOID DoGoto(STRPTR Label, int Num)
  494. { 
  495.   struct ScriptLine *sl;
  496.  
  497.   for(sl = (struct ScriptLine *) ScriptLineList.mlh_Head;
  498.         sl->mn.mln_Succ;
  499.         sl = (struct ScriptLine *) sl->mn.mln_Succ)
  500.   { 
  501.     if (sl->Label  &&  strcmp((char *) sl->Label, (char *) Label) == 0)
  502.     { 
  503.       CurrentScriptLine = (struct ScriptLine *) sl->mn.mln_Pred;
  504.       return;
  505.     }
  506.   }
  507.  
  508.   fprintf(stderr, "Line %d: Unknown label.\n", Num);
  509.   exit(10);
  510. }
  511. VOID OnFunc(struct ScriptLine *line)
  512. { STRPTR ptr = line->Args;
  513.  
  514.   if (strnicmp((char *) ptr, "status", 6) == 0)
  515.   { 
  516.     ptr = SkipBlanks(ptr+6);
  517.     if (strnicmp((char *) ptr, "goto", 4) == 0)
  518.     { 
  519.       STRPTR *labels;
  520.       int i;
  521.  
  522.       if (!StrReadArgs(ptr+4, (LONG *) &labels, (STRPTR) "LABELS/M"))
  523.       { 
  524.         fprintf(stderr, "Line %ld: Memory error.\n", line->Num);
  525.           exit(10);
  526.       }
  527.       for (i = -1;  *labels;  ++i, ++labels)
  528.       { 
  529.         if (i == StatusVar)
  530.           { 
  531.           DoGoto(*labels, line->Num);
  532.             return;
  533.           }
  534.       }
  535.       return;
  536.     }
  537.   }
  538.  
  539.   fprintf(stderr, "Line %ld: Condition syntax.", line->Num);
  540.   exit(10);
  541. }
  542. /**
  543. ***  This function waits for certain strings.
  544. **/
  545. VOID WaitFunc(struct ScriptLine *line)
  546. { 
  547.   struct
  548.   { 
  549.     STRPTR *WaitArgs;
  550.     ULONG *TimeOut;
  551.   } args;
  552.   STRPTR* parsedArgs;
  553.   LONG TimeOut;
  554.   int i = 0;
  555.  
  556.   if(VerboseMode)
  557.     printf("\nWaitFunc: line->Args %s \n",line->Args);
  558.     
  559.   if (!SerialDeviceName)
  560.   { 
  561.     fprintf(stderr, "Line %ld: Must open serial.device first.\n", line->Num);
  562.     exit(10);
  563.   }
  564.  
  565.   args.WaitArgs = NULL;
  566.   args.TimeOut = NULL;
  567.  
  568.   if (!(StrReadArgs(line->Args, (LONG *)&args, (STRPTR) "ARGS/M,TIMEOUT/N/K")))
  569.   { 
  570.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  571.     exit(10);
  572.   }
  573.  
  574.   if (!args.WaitArgs)
  575.   { 
  576.     fprintf(stderr, "Line %ld: Missing argument.\n", line->Num);
  577.     exit(10);
  578.   }
  579.   if (!args.TimeOut)
  580.   { 
  581.     fprintf(stderr, "Line %ld: Missing timeout argument.\n", line->Num);
  582.     exit(10);
  583.   }
  584.   TimeOut = *args.TimeOut;
  585.  
  586.  
  587.   while (args.WaitArgs[i])
  588.   { 
  589.     ++i;
  590.   }
  591.  
  592.   if (!(parsedArgs = malloc(sizeof(STRPTR) * (i+1))))
  593.   { 
  594.     perror("malloc");
  595.     exit(10);
  596.   }
  597.  
  598.   for (i = 0;  args.WaitArgs[i];  i++)
  599.   { 
  600.     parsedArgs[i] = ParseString(args.WaitArgs[i]);
  601.   }
  602.   parsedArgs[i] = NULL;
  603.    
  604.   StatusVar = SerialWait(parsedArgs, TimeOut);
  605. }
  606. /**
  607. ***  The delay function waits for a certain amount of time.
  608. **/
  609. VOID DelayFunc(struct ScriptLine *line)
  610.  
  611. { 
  612.   ULONG tics; 
  613.   
  614.   if (VerboseMode)
  615.     printf("DelayFunc: line->Args: %s\n",(char *) line->Args);
  616.     
  617.   tics = (atoi((char *) line->Args) * 50);
  618.  
  619.   if (tics == 0)
  620.   { 
  621.     fprintf(stderr, "DelayFunc: Line %ld: Missing argument.\n", line->Num);
  622.     exit(10);
  623.   }
  624.  
  625.   Delay(tics);
  626. }
  627. /**
  628. ***  And this is the Exit function.
  629. **/
  630. VOID ExitFunc(struct ScriptLine *line)
  631.  
  632. { 
  633.   LONG result = atol((char *) line->Args);
  634.   exit(result);
  635. }
  636. /**
  637. ***  The Goto command
  638. **/
  639. VOID GotoFunc(struct ScriptLine *line)
  640. { 
  641.   STRPTR Label;
  642.  
  643.   if (!(StrReadArgs(line->Args, (LONG *) &Label, (STRPTR) "LABEL/A")))
  644.   { 
  645.     fprintf(stderr, "Line %ld: Missing argument or memory error.\n",
  646.               line->Num);
  647.     exit(10);
  648.   }
  649.   DoGoto(Label, line->Num);
  650. }
  651. /**
  652. ***  This function enters terminal mode.
  653. **/
  654. VOID TermFunc(struct ScriptLine *line)
  655. { 
  656.   struct
  657.   { 
  658.     STRPTR eof;
  659.     ULONG noecho;
  660.     ULONG raw;
  661.   } args;
  662.  
  663.   args.eof = NULL;
  664.   args.noecho = FALSE;
  665.   args.raw = FALSE;
  666.  
  667.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "EOF,NOECHO/S,RAW/S"))
  668.   { 
  669.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  670.     exit(10);
  671.   }
  672.  
  673.   if (args.eof) 
  674.   {
  675.     args.eof = ParseString(args.eof);
  676.   }
  677.   SerialTerminal(args.eof, !args.noecho, !args.raw);
  678. }
  679. /**
  680. ***  Execute external commands.
  681. **/
  682. VOID SystemFunc(struct ScriptLine *line)
  683. { 
  684.   STRPTR *args;
  685.   int i, result;
  686.   char *cmd;
  687.   STATIC APTR systemBuffer = NULL;
  688.  
  689.   /**
  690.   ***  Initialize buffer.
  691.   **/
  692.   if (!systemBuffer  &&  !(systemBuffer = BufferCreate()))
  693.   { 
  694.     perror("malloc");
  695.     exit(10);
  696.   }
  697.   BufferClear(systemBuffer);
  698.  
  699.  
  700.   if (!StrReadArgs(line->Args, (LONG *) &args, (STRPTR) "ARGS/M"))
  701.   { 
  702.     fprintf(stderr, "Line %ld: Argument or memory error\n", line->Num);
  703.     exit(10);
  704.   }
  705.  
  706.   for(i = 0;  *args;  ++i, ++args)
  707.   { 
  708.     char *str;
  709.  
  710.     if (i)
  711.     { 
  712.       BufferExtend(systemBuffer, (STRPTR) " ", 1);
  713.     }
  714.     str = (char*) ParseString(*args);
  715.     BufferExtend(systemBuffer, (STRPTR) str, strlen(str));
  716.     free(str);
  717.   }
  718.   cmd = (char*) BufferBuffer(systemBuffer);
  719.  
  720.   if (VerboseMode)
  721.   { 
  722.     printf("Executing command: \"%s\"\n", cmd);
  723.   }
  724.   result = system(cmd);
  725.   if (result)
  726.   { 
  727.     if (result > 1  &&  result < 10)  /* Warning */
  728.     { 
  729.       if (VerboseMode)
  730.       { 
  731.         printf("Returned %d.\n", result);
  732.       }
  733.     }
  734.     else
  735.     { printf("Error: Command \"%s\" returned %d.\n", cmd, result);
  736.       exit(result);
  737.     }
  738.   }
  739. }  
  740. /**
  741. ***  Scan the buffer received by the last "wait" command.
  742. **/
  743. VOID ScanFunc(struct ScriptLine *line)
  744. { 
  745.   struct
  746.   { 
  747.     STRPTR format;
  748.     ULONG global;
  749.     ULONG save;
  750.   } args;
  751.   ULONG flags;
  752.  
  753.   args.format = NULL;
  754.   args.global = FALSE;
  755.   args.save = FALSE;
  756.  
  757.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  758.           (STRPTR) "FORMAT/A,GLOBAL/S,SAVE/S")))
  759.   { 
  760.     fprintf(stderr, "Line %ld: Argument or memory error.\n", line->Num);
  761.     exit(10);
  762.   }
  763.  
  764.   flags = 0;
  765.   if (args.save)
  766.   { 
  767.     args.global = TRUE;
  768.     flags |= GVF_SAVE_VAR;
  769.   }
  770.   if (args.global)
  771.   { 
  772.     flags |= GVF_GLOBAL_ONLY;
  773.   }
  774.   else
  775.   { 
  776.     flags |= GVF_LOCAL_ONLY;
  777.   }
  778.  
  779.   StatusVar = Vsscanf(SerialWaitBuffer(), args.format, flags);
  780. }
  781. /**
  782. ***  The SetVar command
  783. **/
  784. void SetVarFunc(struct ScriptLine *line)
  785. { 
  786.   struct 
  787.   {
  788.     STRPTR name;
  789.     STRPTR value;
  790.     ULONG global;
  791.     ULONG save;
  792.   } args;
  793.   int flags;
  794.  
  795.   args.name = NULL;
  796.   args.value = NULL;
  797.   args.global = FALSE;
  798.   args.save = FALSE;
  799.  
  800.   if (!(StrReadArgs(line->Args, (LONG *) &args,
  801.           (STRPTR) "NAME/A,VALUE/A,LOCALONLY/S,GLOBALONLY/S,SAVE/S")))
  802.   { 
  803.     fprintf(stderr, "Line %ld: Missing argument or memory error.\n",
  804.              line->Num);
  805.     exit(10);
  806.   }
  807.  
  808.   flags = 0;
  809.   if (args.save) 
  810.   {
  811.     flags |= GVF_SAVE_VAR;
  812.     args.global = TRUE;
  813.   }
  814.   if (args.global) 
  815.   {
  816.     flags |= GVF_GLOBAL_ONLY;
  817.   } 
  818.   else 
  819.   {
  820.     flags |= GVF_LOCAL_ONLY;
  821.   }
  822.  
  823.   setvar(args.name, args.value, LV_VAR|flags);
  824. }
  825. /**
  826. ***  This is the command table.
  827. **/
  828. struct Command CommandTab[] =
  829. { { EchoFunc,       (STRPTR) "echo"         },
  830.   { DeviceFunc,     (STRPTR) "device"       },
  831.   { SetFunc,        (STRPTR) "set"          },
  832.   { ShowParmsFunc,  (STRPTR) "showparms"    },
  833.   { SendFunc,       (STRPTR) "send"         },
  834.   { OnFunc,         (STRPTR) "on"           },
  835.   { WaitFunc,       (STRPTR) "wait"         },
  836.   { DelayFunc,      (STRPTR) "delay"        },
  837.   { ExitFunc,       (STRPTR) "exit"         },
  838.   { GotoFunc,       (STRPTR) "goto"         },
  839.   { TermFunc,       (STRPTR) "terminal"     },
  840.   { SystemFunc,     (STRPTR) "system"       },
  841.   { ScanFunc,       (STRPTR) "scan"         },
  842.   { SetVarFunc,     (STRPTR) "setvar"       },
  843.   { NULL,           NULL                    }
  844. };
  845. /**
  846. ***  This function is used to process the file. Rather easy,
  847. ***  isn't it? :-)
  848. **/
  849. VOID ProcessFile(VOID)
  850. { 
  851.   for(CurrentScriptLine = (struct ScriptLine *) ScriptLineList.mlh_Head;
  852.       CurrentScriptLine->mn.mln_Succ;
  853.       CurrentScriptLine = (struct ScriptLine *) CurrentScriptLine->mn.mln_Succ)
  854.   { 
  855.     (*CurrentScriptLine->CommFunc)(CurrentScriptLine);
  856.   }
  857. }
  858. /**
  859. ***  This function reads and parses the file.
  860. **/
  861. VOID ParseFile(STRPTR file)
  862. { 
  863.   FILE *fp;
  864.   STATIC UBYTE buffer[4096];
  865.   ULONG linenum = 0;
  866.   ULONG success = TRUE;
  867.  
  868.   if (!(fp = fopen((char *) file, "r")))
  869.   { 
  870.     fprintf(stderr, "Could not open %s for reading.\n", file);
  871.     exit(10);
  872.   }
  873.  
  874.   NewList((struct List *) &ScriptLineList);
  875.  
  876.   while(fgets((char *) buffer, sizeof(buffer), fp))
  877.   { 
  878.     ULONG len = strlen((char *) buffer);
  879.     STRPTR line;
  880.     STRPTR Label = NULL;
  881.     CommandFunc CommFunc;
  882.  
  883.     ++linenum;
  884.  
  885.     if (buffer[len-1] != '\n')
  886.     { 
  887.       fprintf(stderr, "Line %ld too long.\n", linenum);
  888.       exit(10);
  889.     }
  890.  
  891.     if (!(line = malloc(len+1)))
  892.     { 
  893.       perror("malloc");
  894.       exit(10);
  895.     }
  896.     strcpy((char*) line, (char*) buffer);
  897.     
  898.     line = SkipBlanks(line);
  899.  
  900.     /**
  901.     ***  Check for a label
  902.     **/
  903.     { 
  904.       STRPTR ptr = line;
  905.  
  906.       if (isalpha(*ptr))
  907.       { 
  908.         do
  909.           { 
  910.           ++ptr;
  911.           }
  912.           while(isalnum(*ptr));
  913.  
  914.           if (*ptr == ':')
  915.           { 
  916.           *ptr = '\0';
  917.             Label = line;
  918.             line = SkipBlanks(ptr+1);
  919.           }
  920.       }
  921.     }
  922.  
  923.     /**
  924.     ***  Check for empty line or comment line
  925.     **/
  926.     if (*line == ';'  ||  *line == '\r'  ||  *line == '\n')
  927.     { 
  928.       CommFunc = NoneFunc;
  929.       if (!Label)
  930.       { 
  931.         continue;
  932.       }
  933.     }
  934.  
  935.     /**
  936.     ***  If no empty line: Check for command
  937.     **/
  938.     else
  939.     { 
  940.       struct Command *comm;
  941.  
  942.       for (comm = &CommandTab[0];  comm->Func;  ++comm)
  943.       { 
  944.         ULONG len = strlen((char *) comm->Name);
  945.  
  946.           if (strnicmp((char *) comm->Name, (char *) line, len) == 0  &&
  947.              (line[len] == ' '  ||  line[len] == '\t'  ||
  948.               line[len] == '\r' ||  line[len] == '\n'))
  949.           { 
  950.           line = SkipBlanks(line+len);
  951.             CommFunc = comm->Func;
  952.             break;
  953.           }
  954.       }
  955.  
  956.       if (!comm->Func)
  957.       { 
  958.         fprintf(stderr, "Line %ld: Unknown command.\n", linenum);
  959.           success = FALSE;
  960.       }
  961.     }
  962.  
  963.     /**
  964.     ***  Allocate a new scriptline structure.
  965.     **/
  966.     { 
  967.       struct ScriptLine *sl;
  968.  
  969.       if (!(sl = malloc(sizeof(*sl))))
  970.       { 
  971.         perror("malloc");
  972.           exit(10);
  973.       }
  974.  
  975.       AddTail((struct List *) &ScriptLineList, (struct Node *) sl);
  976.       sl->Num = linenum;
  977.       sl->CommFunc = CommFunc;
  978.       sl->Args = line;
  979.       sl->Label = Label;
  980.       /*
  981.       if(VerboseMode)
  982.       {
  983.         printf("\n");
  984.         printf("ParseFile: Num      %d  \n", sl->Num);
  985.         printf("ParseFile: CommFunc 0x%x\n", sl->CommFunc);
  986.         printf("ParseFile: Args     %s  \n", sl->Args);
  987.         printf("ParseFile: Label    %s  \n", sl->Label);
  988.       }
  989.       */
  990.     }
  991.   }
  992.  
  993.   if (ferror(fp))
  994.   { 
  995.     perror("fgets");
  996.     exit(10);
  997.   }
  998.  
  999.   if (!success)
  1000.   { 
  1001.     exit(10);
  1002.   }
  1003.  
  1004.   fclose(fp);
  1005. }
  1006. /**
  1007. ***  This is the Cleanup() function, called, when the program terminates.
  1008. **/
  1009. VOID Cleanup(VOID)
  1010. { 
  1011.   SerialCleanup();
  1012.   StrReadArgsFree();
  1013.   if (MainRDArgs)
  1014.   { 
  1015.     FreeArgs(MainRDArgs);
  1016.   }
  1017. }
  1018. /**
  1019. ***  This function hints about the GPL.
  1020. **/
  1021. VOID ShowGPL(FILE *fp)
  1022. { 
  1023.   fprintf(fp, "This program is governed by the terms and conditions of the\n");
  1024.   fprintf(fp, "GNU General Public License. A copy should have come with\n");
  1025.   fprintf(fp, "this distribution. (See the file COPYING.) In that license\n");
  1026.   fprintf(fp, "it is made clear that you are welcome to redistribute either\n");
  1027.   fprintf(fp, "verbatim or modified copies of the program and the documentation\n");
  1028.   fprintf(fp, "under certain conditions. Further you are told that this program\n");
  1029.   fprintf(fp, "comes with ABSOLUTELY NO WARRANTY!\n");
  1030. }
  1031. /**
  1032. ***  This function displays the Usage() message.
  1033. **/
  1034. VOID Usage(VOID)
  1035. { 
  1036.   fprintf(stderr, "Usage: IPDial SCRIPT,DEVICE/K,PROTOCOL/K,TERMINAL/S,ECHO/S,VERBOSE/S,HELP/S\n\n");
  1037.   fprintf(stderr, "\tSCRIPT:    Script file to execute.\n");
  1038.   fprintf(stderr, "\tDEVICE:    Device to use (default serial.device)\n");
  1039.   fprintf(stderr, "\tPROTOCOL:  Protocol to use; XONXOFF, 7WIRE (default) or NONE)\n");
  1040.   fprintf(stderr, "\tUNIT:      Unit to use (default 0)\n");
  1041.   fprintf(stderr, "\tECHO:      Show modems replies.\n");
  1042.   fprintf(stderr, "\tVERBOSE:   Be verbose.\n\n");
  1043.   fprintf(stderr, "\tTERMINAL:  Run in terminal mode.\n");
  1044.   fprintf(stderr, "\tHELP:      Print this message.\n");
  1045.   fprintf(stderr, "\n\n%s  @ 1994 by Jochen Wiedmann\n\n", VString);
  1046.   ShowGPL(stderr);
  1047.   exit(5);
  1048. }
  1049. /**
  1050. ***  This is main().
  1051. **/
  1052. int main(int argc, char *argv[])
  1053. { 
  1054.   struct
  1055.   { 
  1056.     STRPTR file;
  1057.     STRPTR device;
  1058.     STRPTR protocol;
  1059.     LONG *unit;
  1060.     LONG *baud;
  1061.     ULONG terminal;
  1062.     ULONG help;
  1063.     ULONG echo;
  1064.     ULONG verbose;
  1065.     ULONG raw;
  1066.   } args;
  1067.  
  1068.   args.file = NULL;
  1069.   args.device = (STRPTR) "serial.device";
  1070.   args.protocol = (STRPTR) "7wire";
  1071.   args.unit = NULL;
  1072.   args.baud = NULL;
  1073.   args.terminal = FALSE;
  1074.   args.echo = FALSE;
  1075.   args.verbose = FALSE;
  1076.   args.help = FALSE;
  1077.   args.raw = FALSE;
  1078.  
  1079.   if (!argc)    /*  No WB handling.     */
  1080.   { 
  1081.     exit(-1);
  1082.   }
  1083.  
  1084.   if (atexit(Cleanup))
  1085.   { 
  1086.     fprintf(stderr, "Memory error.\n");
  1087.     exit(20);
  1088.   }
  1089.  
  1090.   if (!(MainRDArgs = ReadArgs((STRPTR) "SCRIPT,DEVICE/K,PROTOCOL/K,"
  1091.                                            "UNIT/K/N,BAUD/K/N,TERMINAL/S,"
  1092.                                              "HELP/S,ECHO/S,VERBOSE/S,RAW/S",
  1093.                                               (LONG *) &args, NULL)))
  1094.   { 
  1095.     fprintf(stderr, "Cannot parse command line.\n");
  1096.   }
  1097.  
  1098.   if (args.help  || (!args.file  &&  !args.terminal))
  1099.   { 
  1100.     Usage();
  1101.   }
  1102.  
  1103.   EchoMode = args.echo;
  1104.   if (args.verbose)
  1105.   { 
  1106.     VerboseMode = TRUE;
  1107.     printf("%s  @ 1994 by Jochen Wiedmann\n\n", VString);
  1108.     ShowGPL(stdout);
  1109.     printf("\n\n");
  1110.   }
  1111.  
  1112.   if (args.terminal)
  1113.   { 
  1114.     if(VerboseMode)
  1115.       printf("\nMain: %d\n",__LINE__);
  1116.       
  1117.     SerialOpen(args.device, args.protocol, args.unit ? *args.unit : 0);
  1118.     if (args.baud)
  1119.     { 
  1120.       if(VerboseMode)
  1121.         printf("\nMain: %d\n",__LINE__);
  1122.       SerialSetBaud(*args.baud);
  1123.     }
  1124.     if(VerboseMode)
  1125.       printf("\nMain: %d\n",__LINE__);
  1126.     SerialTerminal(NULL, TRUE, !args.raw);
  1127.   }
  1128.   else if (args.file)
  1129.   { 
  1130.     if(VerboseMode)
  1131.       printf("\nMain: %d\n",__LINE__);
  1132.     ParseFile(args.file);
  1133.     if(VerboseMode)
  1134.       printf("\nMain: %d\n",__LINE__);
  1135.     ProcessFile();
  1136.   }
  1137.  
  1138.   exit(0);
  1139. }
  1140.